// 导入AR在线状态的绿色图标
import arOnline_g from "@/assets/image/ar/ar-online-g.png";
// 导入AR变更状态的绿色图标
import arChange_g from "@/assets/image/ar/ar-change-g.png";
// 导入AR离线状态的绿色图标
import arOffline_g from "@/assets/image/ar/ar-outline-g.png";
// 导入AR变更且离线状态的绿色图标
import arChangeOffLine_g from "@/assets/image/ar/ar-change-offLine-g.png";
// 导入IPC在线状态的绿色图标
import ipcOnline_g from "@/assets/image/ar/ipc-online-g.png";
// 导入IPC变更状态的绿色图标
import ipcChange_g from "@/assets/image/ar/ipc-change-g.png";
// 导入IPC离线状态的绿色图标
import ipcOffline_g from "@/assets/image/ar/ipc-outline-g.png";
// 导入IPC变更且离线状态的绿色图标
import ipcChangeOffLine_g from "@/assets/image/ar/ipc-change-offLine-g.png";
// 导入AR在线状态的蓝色图标
import arOnline_ly from "@/assets/image/ar_ly/ar-online-ly.png";
// 导入AR变更状态的蓝色图标
import arChange_ly from "@/assets/image/ar_ly/ar-change-ly.png";
// 导入AR离线状态的蓝色图标
import arOffline_ly from "@/assets/image/ar_ly/ar-outline-ly.png";
// 导入AR变更且离线状态的蓝色图标
import arChangeOffLine_ly from "@/assets/image/ar_ly/ar-change-offLine-ly.png";
// 导入IPC变更状态的蓝色图标
import ipcChange_ly from "@/assets/image/ar_ly/ipc-change-ly.png";
// 导入IPC离线状态的蓝色图标
import ipcOffline_ly from "@/assets/image/ar_ly/ipc-outline-ly.png";
// 导入IPC变更且离线状态的蓝色图标
import ipcChangeOffLine_ly from "@/assets/image/ar_ly/ipc-change-offLine-ly.png";
// 导入AR在线状态的默认图标
import arOnline from "@/assets/image/ar/ar-online.png";
// 导入AR变更状态的默认图标
import arChange from "@/assets/image/ar/ar-change.png";
// 导入AR离线状态的默认图标
import arOffline from "@/assets/image/ar/ar-outline.png";
// 导入AR变更且离线状态的默认图标
import arChangeOffLine from "@/assets/image/ar/ar-change-offLine.png";
// 导入IPC在线状态的默认图标
import ipcOnline from "@/assets/image/ar/ipc-online.png";
// 导入IPC变更状态的默认图标
import ipcChange from "@/assets/image/ar/ipc-change.png";
// 导入IPC离线状态的默认图标
import ipcOffline from "@/assets/image/ar/ipc-outline.png";
// 导入IPC变更且离线状态的默认图标
import ipcChangeOffLine from "@/assets/image/ar/ipc-change-offLine.png";
// 导入IPC在线状态的蓝色图标
import ipcOnline_ly from "@/assets/image/ar_ly/ipc-online-ly.png";
// 导入蓝色AR集群图标
import clusterBlue_g from "@/assets/image/cluster-blue-ar-g.png";
// 导入蓝色AR集群的蓝色图标
import clusterBlue_ly from "@/assets/image/ar_ly/cluster-blue-ar-ly.png";
// 导入蓝色AR集群的默认图标
import clusterBlue from "@/assets/image/cluster-blue-ar.png";

/**
 * 根据是否ar和是否在线获取图标
 * @param {boolean} arFlag - 是否ar标志
 * @param {boolean} onlineFlag - 是否在线标志
 * @param industryType 行业类型
 * @returns {object} - 返回包含图标和点击图标的对象
 */
export function getIconByArAndOnLineStatus(arFlag, onlineFlag, industryType) {
  // 定义常量代替魔法数字，提高代码可读性
  // 国土行业类型
  const INDUSTRY_TYPE_GOV = 1;
  // 林业行业类型
  const INDUSTRY_TYPE_FORESTRY = 2;

  // 定义图标映射表，避免硬编码
  const iconMappings = {
    // 国土行业类型的图标映射
    [INDUSTRY_TYPE_GOV]: {
      arOnline: arOnline_g,
      arChange: arChange_g,
      arOffline: arOffline_g,
      arChangeOffLine: arChangeOffLine_g,
      ipcOnline: ipcOnline_g,
      ipcChange: ipcChange_g,
      ipcOffline: ipcOffline_g,
      ipcChangeOffLine: ipcChangeOffLine_g,
    },
    // 林业行业类型的图标映射
    [INDUSTRY_TYPE_FORESTRY]: {
      arOnline: arOnline_ly,
      arChange: arChange_ly,
      arOffline: arOffline_ly,
      arChangeOffLine: arChangeOffLine_ly,
      ipcOnline: arChange_ly,
      ipcChange: ipcChange_ly,
      ipcOffline: ipcOffline_ly,
      ipcChangeOffLine: ipcChangeOffLine_ly,
    },
    // 默认映射，用于 industryType 不是上述值的情况
    default: {
      arOnline: arOnline,
      arChange: arChange,
      arOffline: arOffline,
      arChangeOffLine: arChangeOffLine,
      ipcOnline: ipcOnline,
      ipcChange: ipcChange,
      ipcOffline: ipcOffline,
      ipcChangeOffLine: ipcChangeOffLine,
    },
  };

  // 根据行业类型获取对应的映射表
  const mapping = iconMappings[industryType] || iconMappings.default;

  let icon, clickIcon;

  if (arFlag) {
    // 如果开启了ar
    if (onlineFlag) {
      // 并且在线
      icon = mapping.arOnline;
      clickIcon = mapping.arChange;
    } else {
      // 不在线
      icon = mapping.arOffline;
      clickIcon = mapping.arChangeOffLine;
    }
  } else {
    // 没有开启ar
    if (onlineFlag) {
      // 并且在线
      icon = mapping.ipcOnline;
      clickIcon = mapping.ipcChange;
    } else {
      // 不在线
      icon = mapping.ipcOffline;
      clickIcon = mapping.ipcChangeOffLine;
    }
  }

  return { icon, clickIcon };
}

/**
 * 根据行业类型和类别代码获取标记源URL
 * @param {number} industryType - 行业类型
 * @param {string} categoryCode - 类别代码
 * @returns {string} - 返回标记源URL
 */
export function getMarkerSrcUrl(industryType, categoryCode) {
  let baseUrl;

  // 判断行业类型，设置不同的基准URL
  if (industryType === 1) {
    // 国土
    baseUrl = categoryCode === "2" ? arOnline_g : ipcOnline_g;
  } else if (industryType === 2) {
    // 林业
    baseUrl = categoryCode === "2" ? arOnline_ly : ipcOnline_ly;
  } else {
    // 其他行业类型
    baseUrl = categoryCode === "2" ? arOnline : ipcOnline;
  }

  // 返回基准URL
  return baseUrl;
}

/**
 * 根据行业类型获取在线图标
 * @param {number} industryType - 行业类型
 * @returns {string} - 返回在线图标的URL
 */
export function getOnlineIcon(industryType) {
  // 定义一个对象来映射行业类型到图标
  const iconMap = {
    1: ipcOnline_g,
    2: ipcOnline_ly,
    default: ipcOnline, // 如果没有匹配到，则使用默认图标
  };
  // 使用映射来获取图标
  return iconMap[industryType] || iconMap.default;
}

/**
 * 根据行业类型获取集群图标和归属信息
 * @param {number} industryType - 行业类型
 * @returns {object} - 返回包含集群图标、图片路径、点图片宽高、偏移量等信息的对象
 */
export function getClusterIconAndAttribution(industryType) {
  let clusterImg,
    imgPath,
    pointImgWidth,
    pointImgHeight,
    iOffset,
    clusterImgWidth,
    clusterImgHeight,
    clusterOffset;

  // 判断行业类型并设置相应的集群图标和图片路径
  if (industryType === 1) {
    // 国土
    clusterImg = clusterBlue_g;
    imgPath = ipcOnline_g;
  } else if (industryType === 2) {
    // 林业
    clusterImg = clusterBlue_ly;
    imgPath = ipcOnline_ly;
  } else {
    clusterImg = clusterBlue;
    imgPath = ipcOnline;
  }

  // 判断行业类型并设置点图片宽高、偏移量、集群图标宽高和集群偏移量
  pointImgWidth = 46;
  pointImgHeight = 50;
  iOffset = [23, 44];
  clusterImgWidth = 56;
  clusterImgHeight = 56;
  clusterOffset = [28, 28];

  return {
    clusterImg,
    imgPath,
    pointImgWidth,
    pointImgHeight,
    iOffset,
    clusterImgWidth,
    clusterImgHeight,
    clusterOffset,
  };
}

/**
 * 根据行业类型获取集群图片和属性
 * @param {number} industryType - 行业类型
 * @returns {object} - 返回包含集群图片、宽度、高度、偏移量和质量偏移量的对象
 */
export function getClusterImgAndAttr(industryType) {
  let clusterImg;

  // 判断行业类型并设置相应的集群图片
  if (industryType === 1) {
    // 国土
    clusterImg = clusterBlue_g;
  } else if (industryType === 2) {
    // 林业
    clusterImg = clusterBlue_ly;
  } else {
    clusterImg = clusterBlue;
  }

  let clusterImgWidth, clusterImgHeight, clusterOffset, massOffset;

  // 判断行业类型并设置集群图片的宽度、高度、偏移量和质量偏移量
  if (industryType === 2) {
    // 林业
    clusterImgWidth = 56;
    clusterImgHeight = 56;
    clusterOffset = [28, 28];
    massOffset = "28, 28";
  } else {
    clusterImgWidth = 48;
    clusterImgHeight = 48;
    clusterOffset = [24, 24];
    massOffset = "24, 24";
  }

  return {
    clusterImg,
    clusterImgWidth,
    clusterImgHeight,
    clusterOffset,
    massOffset,
  };
}

/**
 * 获取点图片属性
 * @param industryType
 * @returns {*|{pointImgWidth: number, iOffset: number[], pointImgHeight: number}}
 */
export function getPointImgAttr(industryType) {
  // 定义一个对象来映射行业类型到图片尺寸和偏移量
  const imagePropsMap = {
    2: {
      // 林业的点图片宽度
      pointImgWidth: 46,
      // 林业的点图片高度
      pointImgHeight: 50,
      // 林业的点图片偏移量
      iOffset: [23, 44],
    },
    default: {
      // 林业的点图片宽度
      pointImgWidth: 46,
      // 林业的点图片高度
      pointImgHeight: 50,
      // 林业的点图片偏移量
      iOffset: [23, 44],
    },
  };
  // 根据行业类型返回对应的图片属性，若不存在则返回默认属性
  return imagePropsMap[industryType] || imagePropsMap.default;
}

/**
 * 处理站址数据
 * @param list
 * @returns {*}
 */
export function formatSiteList(list) {
  // 处理成同一站址设备一个数组的对象
  const deviceObj = {};
  let deviceList = [];

  list.forEach((siteItem) => {
    const itemList = siteItem.list;
    const dList = [];
    for (const element of itemList) {
      if (element.status === "0" || element.allLine === "0") {
        // 在线
        dList.push(element.deviceCode);
      }
    }
    deviceObj[siteItem.siteCode] = dList;

    // 将每个设备的经纬度、站址编码等信息补充完整
    for (const itemElement of itemList) {
      itemElement.longitude = siteItem.longitude;
      itemElement.latitude = siteItem.latitude;
      itemElement.siteCode = siteItem.siteCode;
    }

    // 将所有设备信息推入设备列表
    deviceList.push(...itemList);

    // 初始化是否显示ar设备和是否在线的标志
    let arFlag = false; // 是否显示ar设备
    let onlineFlag = false; // 是否在线
    let iList = siteItem.list;

    // 遍历设备列表，根据状态判断设备是否在线和是否为AR设备
    iList.forEach((deviceItem) => {
      if (deviceItem.status === "0" || deviceItem.allLine === "0") {
        // 在线
        onlineFlag = true;
      }
      if (String(deviceItem.categoryCode) === "2") {
        // AR设备
        arFlag = true; // 一旦找到AR设备，就设置arFlag为true
      }
    });

    // 设置站址的arFlag和onlineFlag属性
    siteItem.arFlag = arFlag;
    siteItem.onlineFlag = onlineFlag;

    // 根据arFlag和onlineFlag获取图标
    let { icon, clickIcon } = getIconByArAndOnLineStatus(arFlag, onlineFlag);
    siteItem.icon = icon;
    siteItem.clickIcon = clickIcon;
  });

  return {
    siteList: list,
    deviceObj: deviceObj,
    deviceList: deviceList,
  };
}

/**
 * 点聚合数据格式化
 */
export function formatClusterList(list, attrObj, iconObj, is3D) {
  // 从属性对象中获取经度、纬度和ID属性名
  const { longitudeAttr, latitudeAttr, idAttr } = attrObj;
  // 从图标对象中获取图片路径、点图片宽度、点图片高度和图标偏移量
  const { imgPath, pointImgWidth, pointImgHeight, iconOffset } = iconObj;

  let returnList = [];

  // 遍历列表中的每个项目
  for (const item of list) {
    // 从项目中获取经度、纬度和ID值
    const longitude = item[longitudeAttr];
    const latitude = item[latitudeAttr];
    const id = item[idAttr];
    let idStr = id;

    // 如果经度、纬度和ID值都不存在，则跳过当前项目
    if (!(longitude && latitude && id)) {
      continue;
    }

    // 根据属性对象中的图标属性名获取图标路径，如果不存在则使用默认的图片路径
    const icon =
      attrObj.iconAttr != null ? item[attrObj.iconAttr] || imgPath : imgPath;
    // 根据属性对象中的点击图标属性名获取点击图标路径，如果不存在则使用图标路径
    const clickIcon =
      attrObj.clickIconAttr != null ? item[attrObj.clickIconAttr] : icon;

    let param;

    // 判断是否为三维模式
    if (is3D) {
      // 三维模式
      // 设置三维模式下的参数
      param = {
        weight: 8,
        icon: icon,
        iconSize: [pointImgWidth, pointImgHeight],
        offset: iconOffset,
        iconOffset: iconOffset,
        clickIcon: clickIcon,
        clickBig: false,
        arFlag: item.arFlag,
        onlineFlag: item.onlineFlag,
      };
      // 如果属性对象中存在可点击属性，则将其添加到参数中
      if (attrObj.clickable != null) {
        param.clickable = attrObj.clickable;
      }
      // 设置ID和经纬度
      param.id = idStr;
      param.lnglat = [Number(longitude), Number(latitude)];
    } else {
      // 非三维模式
      // 设置非三维模式下的参数
      param = {
        id: idStr,
        longitude: Number(longitude),
        latitude: Number(latitude),
        iconSize: [pointImgWidth, pointImgHeight],
        icon: icon,
        clickIcon: clickIcon,
        offset: iconOffset,
        arFlag: item.arFlag,
        onlineFlag: item.onlineFlag,
      };
    }

    // 将参数添加到返回列表中
    returnList.push(param);
  }

  // 返回格式化后的列表
  return returnList;
}

/**
 * 执行传入的函数
 *
 *  func - 要执行的函数
 *  param - 第一个参数，如果为null或undefined则不传递
 *  param2 - 第二个参数，如果第一个参数为null或undefined则不传递
 */
export function executeFunction(func, param, param2) {
  // 如果传入的函数存在
  if (func) {
    // 如果第一个参数不为null或undefined
    if (param != null) {
      // 执行函数，并传递两个参数
      func(param, param2);
    } else {
      // 如果第一个参数为null或undefined，则只执行函数，不传递参数
      func();
    }
  }
}

//错误提示
export const ErrorMassages = [
  "当前监控范围数据缺失,无法显示",
  "当前设备无监控范围或监控角度",
  "当前网格未标绘",
  "未获取到信息详情，请联系管理员！",
  "未查询到摄像机详细信息",
  "请输入位置的关键字",
  "未查询到网格员详细信息",
  "当前设备无通道信息",
  "当前",
  "网格未标绘",
];

/**
 * 获取天气图标
 */
export function getWeatherForMap(data) {
  // 如果数据为空，则返回false
  if (Object.keys(data).length === 0) {
    return false;
  }

  let iconStr;

  // 如果天气包含“雨”，则设置图标为“雨”
  if (data.weather.indexOf("雨") > -1) {
    iconStr = "yu";
  }
  // 如果天气包含“雪”，则设置图标为“雪”
  else if (data.weather.indexOf("雪") > -1) {
    iconStr = "xue";
  }
  // 如果天气包含“晴”，则设置图标为“晴”
  else if (data.weather.indexOf("晴") > -1) {
    iconStr = "qing";
  }
  // 如果天气包含“云”，则设置图标为“多云”
  else if (data.weather.indexOf("云") > -1) {
    iconStr = "duoyun";
  }
  // 其余情况默认为“阴天”
  else {
    //其余全是阴
    iconStr = "yintian";
  }
  let weather = {
    iconStr: iconStr, //天气字符转图标
    temperature: data.temperature, //温度
    wind: data.winddirection + "风" + data.windpower + "级", //风
    humidity: data.humidity, //湿度
  };
  return weather;
}

/**
 * 控制地图层级最大和最小
 * @param zoom
 * @param is3d
 */
export function getMapZoomMinMax(zoom, is3d) {
  let max = 18;
  let min = 5;
  let min3D = 4;

  // 如果zoom大于最大值，则将其设置为最大值
  if (zoom > max) {
    zoom = max;
  }

  // 判断是否为3D地图
  if (is3d) {
    // 如果是3D地图，且zoom小于3D地图的最小值，则将其设置为3D地图的最小值
    if (zoom < min3D) {
      zoom = min3D;
    }
  } else {
    // 如果不是3D地图，且zoom小于2D地图的最小值，则将其设置为2D地图的最小值
    if (zoom < min) {
      zoom = min;
    }
  }

  return zoom;
}

/**
 * 获取marker的extData
 */
export function getMarkerExtData(context) {
  // 初始化marker变量
  let marker = null;

  // 判断context对象是否存在target属性
  if (context.target) {
    // 从context的target属性中获取extData
    let tempMarker = context.target.getExtData();
    // 从tempMarker数组的第一个元素中获取marker对象
    marker = tempMarker?.[0].marker;
  } else {
    // 如果context没有target属性，则直接将context赋值给marker
    marker = context;
  }

  // 返回marker对象的option属性中的extData
  return marker.option.extData;
}

/**
 * 显示数量null显示0
 */
export function showNum(value) {
  // 如果value为null或undefined，则返回字符串"0"
  // 否则，返回value本身
  return value == null ? "0" : value;
}

/**
 * 根据行业类型获取元素的宽度、高度和偏移量
 *
 * @param {number} industryType - 行业类型
 * @returns {Object} - 包含元素的宽度、高度和偏移量的对象
 */
export function getEl() {
  let width, height, x, y;
  width = 46;
  // 设置林业行业的元素高度
  height = 50;
  // 设置林业行业的元素x轴偏移量
  x = -23;
  // 设置林业行业的元素y轴偏移量
  y = -44;
  return { width, height, x, y };
}

/**
 * 根据类型获取对应的偏移量
 *
 * @param {string} type - 类型标识
 * @returns {number[]} - 返回一个包含两个数字的数组，表示偏移量
 */
export function getOffsetForType(type) {
  // 如果类型标识为"7"
  if (type === "7") {
    // 返回偏移量 [-29, -29]
    return [-29, -29];
  }
  // 否则返回偏移量 [-17, -17]
  return [-17, -17];
}

/**
 * 根据类型获取Z轴索引值
 *
 * @param {string} type - 类型标识
 * @returns {number} - 返回对应的Z轴索引值
 */
export function getZIndexForType(type) {
  // 如果类型标识为"4"，则返回101
  if (type === "4") {
    return 101;
  }
  // 否则，返回默认的Z轴索引值100
  return 100;
}
